#!/usr/bin/env lua
-- Lua Battle System - 错误处理体系测试脚本
-- 测试错误处理优化后的功能和性能

-- 设置Lua路径
package.path = package.path .. ';src/?.lua;src/utils/?.lua;tests/?.lua;tests/unit/?.lua'

local TestFramework = require("src.utils.test_framework")
local ErrorHandler = require("src.utils.error_handler")
local Errors = require("src.utils.errors")

local function run_error_handling_tests()
    local suite = TestFramework.create_suite("错误处理体系优化测试")

    -- 测试1：错误类型扩展验证
    suite:add_test("错误类型扩展验证", function()
        -- 验证新增的错误类型
        TestFramework.Assert.is_not_nil(Errors.types.MEMORY_ERROR, "MEMORY_ERROR应该存在")
        TestFramework.Assert.is_not_nil(Errors.types.FILE_ERROR, "FILE_ERROR应该存在")
        TestFramework.Assert.is_not_nil(Errors.types.NETWORK_ERROR, "NETWORK_ERROR应该存在")
        TestFramework.Assert.is_not_nil(Errors.types.TIMEOUT_ERROR, "TIMEOUT_ERROR应该存在")
        TestFramework.Assert.is_not_nil(Errors.types.PERFORMANCE_ERROR, "PERFORMANCE_ERROR应该存在")
        TestFramework.Assert.is_not_nil(Errors.types.DATA_CORRUPTION, "DATA_CORRUPTION应该存在")

        -- 验证错误信息模板
        TestFramework.Assert.is_not_nil(Errors.messages.MEMORY_ERROR, "MEMORY_ERROR模板应该存在")
        TestFramework.Assert.is_not_nil(Errors.messages.FILE_ERROR, "FILE_ERROR模板应该存在")
        TestFramework.Assert.is_not_nil(Errors.messages.PERFORMANCE_ERROR, "PERFORMANCE_ERROR模板应该存在")
    end)

    -- 测试2：错误上下文信息收集
    suite:add_test("错误上下文信息收集", function()
        -- 设置测试上下文
        Errors.ContextManager.set_battle_context("test_battle_001")
        Errors.ContextManager.set_character_context("test_char_001")
        Errors.ContextManager.set_module_context("test_module")

        -- 创建带上下文的错误
        local error_obj = Errors:create_with_context(
            Errors.SKILL_ERROR,
            "测试技能错误",
            "测试详情",
            {operation = "cast_skill", function_name = "test_func"}
        )

        TestFramework.Assert.is_not_nil(error_obj.context, "错误对象应该有上下文信息")
        TestFramework.Assert.equals("test_battle_001", error_obj.context.battle_id, "战斗ID应该正确")
        TestFramework.Assert.equals("test_char_001", error_obj.context.character_id, "角色ID应该正确")
        TestFramework.Assert.equals("test_module", error_obj.context.module, "模块名应该正确")
        TestFramework.Assert.equals("cast_skill", error_obj.context.operation, "操作名应该正确")

        -- 测试上下文摘要
        local summary = Errors:get_context_summary(error_obj)
        TestFramework.Assert.is_true(string.find(summary, "battle_id:test_battle_001") ~= nil, "摘要应包含战斗ID")

        -- 清除上下文
        Errors.ContextManager.clear_global_context()
    end)

    -- 测试3：增强堆栈跟踪
    suite:add_test("增强堆栈跟踪", function()
        -- 创建一个会产生错误的函数
        local function problematic_function()
            local function nested_function()
                error("测试错误信息", 2)
            end
            nested_function()
        end

        -- 捕获错误并分析堆栈跟踪
        local success, error_msg = pcall(problematic_function)
        TestFramework.Assert.is_false(success, "函数应该失败")

        -- 解析错误
        local stack_trace = debug.traceback()
        local enhanced_stack = ErrorHandler:enhance_stack_trace(stack_trace)
        local stack_summary = ErrorHandler:create_stack_summary(stack_trace)

        TestFramework.Assert.is_not_nil(enhanced_stack, "增强堆栈跟踪不应该为空")
        TestFramework.Assert.is_not_nil(stack_summary, "堆栈摘要不应该为空")
        TestFramework.Assert.is_type("table", stack_summary, "堆栈摘要应该是表")
        TestFramework.Assert.is_true(stack_summary.call_depth > 0, "调用深度应该大于0")

        -- 验证调用者信息功能
        local caller_info = ErrorHandler:get_caller_info(1)
        TestFramework.Assert.is_not_nil(caller_info, "调用者信息不应该为空")
        TestFramework.Assert.is_not_nil(caller_info.name, "调用者名称不应该为空")
    end)

    -- 测试4：错误恢复机制
    suite:add_test("错误恢复机制", function()
        local attempt_count = 0
        local failing_function = function()
            attempt_count = attempt_count + 1
            if attempt_count < 3 then
                error("模拟临时错误")
            end
            return "success"
        end

        -- 测试安全执行
        local success, result = ErrorHandler:safe_execute(failing_function)
        TestFramework.Assert.is_true(success, "错误恢复应该成功")
        TestFramework.Assert.equals("success", result, "应该返回正确结果")
        TestFramework.Assert.equals(3, attempt_count, "应该重试了3次")

        -- 测试重试操作
        attempt_count = 0
        local retry_result = ErrorHandler:retry_operation(failing_function)
        TestFramework.Assert.is_true(retry_result.success, "重试应该成功")
        TestFramework.Assert.equals(3, retry_result.attempts, "应该重试了3次")

        -- 获取恢复历史
        local recovery_history = ErrorHandler:get_recovery_history()
        TestFramework.Assert.is_type("table", recovery_history, "恢复历史应该是表")
    end)

    -- 测试5：性能监控功能
    suite:add_test("性能监控功能", function()
        -- 测试性能计时器
        ErrorHandler:start_performance_timer("test_timer")

        -- 模拟一些工作
        local sum = 0
        for i = 1, 1000 do
            sum = sum + i
        end

        local performance_data = ErrorHandler:stop_performance_timer("test_timer")
        TestFramework.Assert.is_not_nil(performance_data, "性能数据不应该为空")
        TestFramework.Assert.is_true(performance_data.duration_ms >= 0, "持续时间应该非负")

        -- 测试内存监控
        local memory_data = ErrorHandler:record_memory_usage("test_memory_test")
        TestFramework.Assert.is_not_nil(memory_data, "内存数据不应该为空")
        TestFramework.Assert.is_true(memory_data.memory_mb > 0, "内存使用应该大于0")

        -- 测试错误频率记录
        ErrorHandler:record_error_frequency("TEST_ERROR", "test error message")

        -- 获取性能报告
        local performance_report = ErrorHandler:get_performance_report()
        TestFramework.Assert.is_not_nil(performance_report, "性能报告不应该为空")
        TestFramework.Assert.is_true(performance_report.monitoring_enabled, "监控应该启用")

        -- 测试性能警报
        local alerts = ErrorHandler:check_performance_alerts()
        TestFramework.Assert.is_type("table", alerts, "警报应该是表")
    end)

    -- 测试6：错误统计信息
    suite:add_test("错误统计信息", function()
        -- 记录一些测试错误
        ErrorHandler:record_error("SYSTEM_ERROR", "测试系统错误")
        ErrorHandler:record_error("SKILL_ERROR", "测试技能错误")
        ErrorHandler:record_error("SYSTEM_ERROR", "另一个系统错误")

        -- 获取统计信息
        local stats = ErrorHandler:get_error_stats()
        TestFramework.Assert.is_not_nil(stats, "统计信息不应该为空")
        TestFramework.Assert.is_true(stats.total_errors >= 3, "总错误数应该至少为3")
        TestFramework.Assert.is_not_nil(stats.error_types, "错误类型统计不应该为空")

        -- 验证错误类型计数
        local system_errors = stats.error_types["SYSTEM_ERROR"] or 0
        local skill_errors = stats.error_types["SKILL_ERROR"] or 0
        TestFramework.Assert.is_true(system_errors >= 2, "系统错误应该至少有2个")
        TestFramework.Assert.is_true(skill_errors >= 1, "技能错误应该至少有1个")
    end)

    -- 测试7：错误格式化响应
    suite:add_test("错误格式化响应", function()
        -- 创建测试错误对象
        local test_error = Errors:create_with_context(
            Errors.CONFIG_ERROR,
            "测试配置错误",
            "配置文件未找到",
            {module = "ConfigLoader", operation = "load_config"}
        )

        -- 格式化错误响应
        local formatted = ErrorHandler:format_error_response(test_error)
        TestFramework.Assert.is_not_nil(formatted, "格式化响应不应该为空")
        TestFramework.Assert.is_true(string.find(formatted, "配置错误") ~= nil, "应包含错误类型")
        TestFramework.Assert.is_true(string.find(formatted, "配置文件未找到") ~= nil, "应包含错误信息")
        TestFramework.Assert.is_true(string.find(formatted, "ConfigLoader") ~= nil, "应包含模块信息")
    end)

    -- 测试8：综合错误处理流程
    suite:add_test("综合错误处理流程", function()
        -- 设置测试环境
        Errors.ContextManager.set_battle_context("battle_123")
        ErrorHandler:configure({enable_debug_info = true, enable_stack_trace = true})

        -- 定义可能失败的函数
        local function test_operation(should_fail)
            if should_fail then
                error("模拟操作失败")
            end
            return "operation_success"
        end

        -- 使用完整错误处理流程
        local success, result = ErrorHandler:handle_error(function()
            return test_operation(false)
        end)

        TestFramework.Assert.is_true(success, "成功操作应该通过")
        TestFramework.Assert.equals("operation_success", result, "应该返回正确结果")

        -- 测试失败操作
        local fail_success, fail_result = ErrorHandler:handle_error(function()
            return test_operation(true)
        end)

        TestFramework.Assert.is_false(fail_success, "失败操作应该被捕获")
        TestFramework.Assert.is_not_nil(fail_result, "应该返回错误对象")
        TestFramework.Assert.is_true(fail_result.type ~= nil, "错误对象应该有类型")

        -- 清理
        Errors.ContextManager.clear_global_context()
    end)

    -- 运行所有测试
    print("开始运行错误处理体系优化测试...")
    return suite:run()
end

-- 主程序
if arg and arg[0] and string.match(arg[0], "test_error_handling%.lua$") then
    local results = run_error_handling_tests()

    -- 输出测试总结
    print("\n" .. string.rep("=", 60))
    print("错误处理体系优化测试总结")
    print(string.rep("=", 60))

    if results then
        print(string.format("总测试数: %d", results.total_tests))
        print(string.format("通过测试: %d", results.passed_tests))
        print(string.format("失败测试: %d", results.failed_tests))
        print(string.format("错误测试: %d", results.error_tests))
        print(string.format("成功率: %.2f%%", results.passed_tests / results.total_tests * 100))

        if results.passed_tests == results.total_tests then
            print("\n🎉 所有错误处理优化测试通过！系统功能正常。")
        else
            print("\n⚠️ 部分测试失败，请检查相关功能。")
        end
    else
        print("\n❌ 测试执行失败")
    end
end

-- 导出测试函数供其他模块使用
return {
    run_tests = run_error_handling_tests
}